home *** CD-ROM | disk | FTP | other *** search
/ Celestin Apprentice 4 / Apprentice-Release4.iso / Source Code / Libraries / Apache 1.0 / src / http_core.c < prev    next >
Text File  |  1995-12-04  |  23KB  |  705 lines
  1.  
  2. /* ====================================================================
  3.  * Copyright (c) 1995 The Apache Group.  All rights reserved.
  4.  *
  5.  * Redistribution and use in source and binary forms, with or without
  6.  * modification, are permitted provided that the following conditions
  7.  * are met:
  8.  *
  9.  * 1. Redistributions of source code must retain the above copyright
  10.  *    notice, this list of conditions and the following disclaimer. 
  11.  *
  12.  * 2. Redistributions in binary form must reproduce the above copyright
  13.  *    notice, this list of conditions and the following disclaimer in
  14.  *    the documentation and/or other materials provided with the
  15.  *    distribution.
  16.  *
  17.  * 3. All advertising materials mentioning features or use of this
  18.  *    software must display the following acknowledgment:
  19.  *    "This product includes software developed by the Apache Group
  20.  *    for use in the Apache HTTP server project (http://www.apache.org/)."
  21.  *
  22.  * 4. The names "Apache Server" and "Apache Group" must not be used to
  23.  *    endorse or promote products derived from this software without
  24.  *    prior written permission.
  25.  *
  26.  * 5. Redistributions of any form whatsoever must retain the following
  27.  *    acknowledgment:
  28.  *    "This product includes software developed by the Apache Group
  29.  *    for use in the Apache HTTP server project (http://www.apache.org/)."
  30.  *
  31.  * THIS SOFTWARE IS PROVIDED BY THE APACHE GROUP ``AS IS'' AND ANY
  32.  * EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  33.  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  34.  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE APACHE GROUP OR
  35.  * IT'S CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  36.  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  37.  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  38.  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  39.  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
  40.  * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  41.  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
  42.  * OF THE POSSIBILITY OF SUCH DAMAGE.
  43.  * ====================================================================
  44.  *
  45.  * This software consists of voluntary contributions made by many
  46.  * individuals on behalf of the Apache Group and was originally based
  47.  * on public domain software written at the National Center for
  48.  * Supercomputing Applications, University of Illinois, Urbana-Champaign.
  49.  * For more information on the Apache Group and the Apache HTTP server
  50.  * project, please see <http://www.apache.org/>.
  51.  *
  52.  */
  53.  
  54.  
  55. #define CORE_PRIVATE
  56. #include "httpd.h"
  57. #include "http_config.h"
  58. #include "http_core.h"
  59. #include "http_protocol.h"    /* For index_of_response().  Grump. */
  60. #include "http_conf_globals.h"
  61.  
  62. #include "http_main.h"        /* For the default_handler below... */
  63. #include "http_log.h"
  64.  
  65. /* Server core module... This module provides support for really basic
  66.  * server operations, including options and commands which control the
  67.  * operation of other modules.  Consider this the bureaucracy module.
  68.  *
  69.  * The core module also defines handlers, etc., do handle just enough
  70.  * to allow a server with the core module ONLY to actually serve documents
  71.  * (though it slaps DefaultType on all of 'em); this was useful in testing,
  72.  * but may not be worth preserving.
  73.  *
  74.  * This file could almost be mod_core.c, except for the stuff which affects
  75.  * the http_conf_globals.
  76.  */
  77.  
  78. void *create_core_dir_config (pool *a, char *dir)
  79. {
  80.     core_dir_config *conf =
  81.       (core_dir_config *)pcalloc(a, sizeof(core_dir_config));
  82.   
  83.     if (!dir || dir[strlen(dir) - 1] == '/') conf->d = dir;
  84.     else conf->d = pstrcat (a, dir, "/", NULL);
  85.  
  86.     conf->opts = dir ? OPT_UNSET : OPT_ALL;
  87.     conf->override = dir ? OR_UNSET : OR_ALL;
  88.  
  89.     return (void *)conf;
  90. }
  91.  
  92. void *merge_core_dir_configs (pool *a, void *basev, void *newv)
  93. {
  94.     core_dir_config *base = (core_dir_config *)basev;
  95.     core_dir_config *new = (core_dir_config *)newv;
  96.     core_dir_config *conf =
  97.       (core_dir_config *)pcalloc (a, sizeof(core_dir_config));
  98.     int i;
  99.   
  100.     memcpy ((char *)conf, (const char *)base, sizeof(core_dir_config));
  101.     
  102.     conf->d = new->d;
  103.     
  104.     if (new->opts != OPT_UNSET) conf->opts = new->opts;
  105.     if (new->override != OR_UNSET) conf->override = new->override;
  106.     if (new->default_type) conf->default_type = new->default_type;
  107.     
  108.     if (new->auth_type) conf->auth_type = new->auth_type;
  109.     if (new->auth_name) conf->auth_name = new->auth_name;
  110.     if (new->requires) conf->requires = new->requires;
  111.  
  112.     for (i = 0; i <= RESPONSE_CODES; ++i)
  113.         if (new->response_code_strings[i] != NULL)
  114.        conf->response_code_strings[i] = new->response_code_strings[i];
  115.  
  116.     return (void*)conf;
  117. }
  118.  
  119. void *create_core_server_config (pool *a, server_rec *s)
  120. {
  121.     core_server_config *conf =
  122.       (core_server_config *)pcalloc(a, sizeof(core_server_config));
  123.     int is_virtual = is_virtual_server (s);
  124.   
  125.     conf->access_name = is_virtual ? NULL : DEFAULT_ACCESS_FNAME;
  126.     conf->document_root = is_virtual ? NULL : DOCUMENT_LOCATION;
  127.     conf->sec = make_array (a, 40, sizeof(void *));
  128.     
  129.     return (void *)conf;
  130. }
  131.  
  132. void *merge_core_server_configs (pool *p, void *basev, void *virtv)
  133. {
  134.     core_server_config *base = (core_server_config *)basev;
  135.     core_server_config *virt = (core_server_config *)virtv;
  136.     core_server_config *conf = 
  137.     (core_server_config *)pcalloc(p, sizeof(core_server_config));
  138.  
  139.     *conf = *virt;
  140.     if (!conf->access_name) conf->access_name = base->access_name;
  141.     if (!conf->document_root) conf->document_root = base->document_root;
  142.     conf->sec = append_arrays (p, virt->sec, base->sec);
  143.  
  144.     return conf;
  145. }
  146.  
  147. /* Add per-directory configuration entry (for <directory> section);
  148.  * these are part of the core server config.
  149.  */
  150.  
  151. void add_per_dir_conf (server_rec *s, void *dir_config)
  152. {
  153.     core_server_config *sconf = get_module_config (s->module_config,
  154.                            &core_module);
  155.     void **new_space = (void **) push_array (sconf->sec);
  156.     
  157.     *new_space = dir_config;
  158. }
  159.  
  160. /*****************************************************************
  161.  *
  162.  * There are some elements of the core config structures in which
  163.  * other modules have a legitimate interest (this is ugly, but necessary
  164.  * to preserve NCSA back-compatibility).  So, we have a bunch of accessors
  165.  * here...
  166.  */
  167.  
  168. int allow_options (request_rec *r)
  169. {
  170.     core_dir_config *conf = 
  171.       (core_dir_config *)get_module_config(r->per_dir_config, &core_module); 
  172.  
  173.     return conf->opts; 
  174. } 
  175.  
  176. int allow_overrides (request_rec *r) 
  177. { 
  178.     core_dir_config *conf = 
  179.       (core_dir_config *)get_module_config(r->per_dir_config, &core_module); 
  180.  
  181.     return conf->override; 
  182. } 
  183.  
  184. char *auth_type (request_rec *r)
  185. {
  186.     core_dir_config *conf = 
  187.       (core_dir_config *)get_module_config(r->per_dir_config, &core_module); 
  188.  
  189.     return conf->auth_type;
  190. }
  191.  
  192. char *auth_name (request_rec *r)
  193. {
  194.     core_dir_config *conf = 
  195.       (core_dir_config *)get_module_config(r->per_dir_config, &core_module); 
  196.  
  197.     return conf->auth_name;
  198. }
  199.  
  200. char *default_type (request_rec *r)
  201. {
  202.     core_dir_config *conf = 
  203.       (core_dir_config *)get_module_config(r->per_dir_config, &core_module); 
  204.  
  205.     return conf->default_type ? conf->default_type : DEFAULT_TYPE;
  206. }
  207.  
  208. char *document_root (request_rec *r) /* Don't use this!!! */
  209. {
  210.     core_server_config *conf = 
  211.       (core_server_config *)get_module_config(r->server->module_config,
  212.                           &core_module); 
  213.  
  214.     return conf->document_root;
  215. }
  216.  
  217. array_header *requires (request_rec *r)
  218. {
  219.     core_dir_config *conf = 
  220.       (core_dir_config *)get_module_config(r->per_dir_config, &core_module); 
  221.  
  222.     return conf->requires;
  223. }
  224.  
  225.  
  226. /* Should probably just get rid of this... the only code that cares is
  227.  * part of the core anyway (and in fact, it isn't publicised to other
  228.  * modules).
  229.  */
  230.  
  231. char *response_code_string (request_rec *r, int error_index)
  232. {
  233.     core_dir_config *conf = 
  234.       (core_dir_config *)get_module_config(r->per_dir_config, &core_module); 
  235.  
  236.     return conf->response_code_strings[error_index];
  237. }
  238.  
  239. /*****************************************************************
  240.  *
  241.  * Commands... this module handles almost all of the NCSA httpd.conf
  242.  * commands, but most of the old srm.conf is in the the modules.
  243.  */
  244.  
  245. char *set_access_name (cmd_parms *cmd, void *dummy, char *arg)
  246. {
  247.     void *sconf = cmd->server->module_config;
  248.     core_server_config *conf = get_module_config (sconf, &core_module);
  249.   
  250.     conf->access_name = arg;
  251.     return NULL;
  252. }
  253.  
  254. char *set_document_root (cmd_parms *cmd, void *dummy, char *arg)
  255. {
  256.     void *sconf = cmd->server->module_config;
  257.     core_server_config *conf = get_module_config (sconf, &core_module);
  258.   
  259.     if (!is_directory (arg)) return "DocumentRoot must be a directory";
  260.     
  261.     conf->document_root = arg;
  262.     return NULL;
  263. }
  264.  
  265. char *set_error_document (cmd_parms *cmd, core_dir_config *conf, char *line)
  266. {
  267.     int error_number, index_number;
  268.     char *w;
  269.                 
  270.     /* 1st parameter should be a 3 digit number, which we recognize;
  271.      * convert it into an array index
  272.      */
  273.   
  274.     w = getword_conf (cmd->pool, &line);
  275.     error_number = atoi(w);
  276.     index_number = index_of_response(error_number);
  277.   
  278.     if (index_number < 0)
  279.         return pstrcat (cmd->pool, "Illegal HTTP response code ", w, NULL);
  280.                 
  281.     /* Nuke trailing '"', if present */
  282.     
  283.     if (line[strlen(line) - 1] == '"') line[strlen(line) - 1] = '\0';
  284.   
  285.     /* Store it... */
  286.  
  287.     conf->response_code_strings[index_number] = pstrdup (cmd->pool, line);
  288.  
  289.     return NULL;
  290. }
  291.  
  292. /* access.conf commands...
  293.  *
  294.  * The *only* thing that can appear in access.conf at top level is a
  295.  * <Directory> section.  NB we need to have a way to cut the srm_command_loop
  296.  * invoked by dirsection (i.e., <Directory>) short when </Directory> is seen.
  297.  * We do that by returning an error, which dirsection itself recognizes and
  298.  * discards as harmless.  Cheesy, but it works.
  299.  */
  300.  
  301. char *set_override (cmd_parms *cmd, core_dir_config *d, char *l)
  302. {
  303.     char *w;
  304.   
  305.     d->override = OR_NONE;
  306.     while(l[0]) {
  307.         w = getword_conf (cmd->pool, &l);
  308.     if(!strcasecmp(w,"Limit"))
  309.         d->override |= OR_LIMIT;
  310.     else if(!strcasecmp(w,"Options"))
  311.         d->override |= OR_OPTIONS;
  312.     else if(!strcasecmp(w,"FileInfo"))
  313.             d->override |= OR_FILEINFO;
  314.     else if(!strcasecmp(w,"AuthConfig"))
  315.         d->override |= OR_AUTHCFG;
  316.     else if(!strcasecmp(w,"Indexes"))
  317.             d->override |= OR_INDEXES;
  318.     else if(!strcasecmp(w,"None"))
  319.         d->override = OR_NONE;
  320.     else if(!strcasecmp(w,"All")) 
  321.         d->override = OR_ALL;
  322.     else 
  323.         return pstrcat (cmd->pool, "Illegal override option ", w, NULL);
  324.     }
  325.  
  326.     return NULL;
  327. }
  328.  
  329. char *set_options (cmd_parms *cmd, core_dir_config *d, char *l)
  330. {
  331.     d->opts = OPT_NONE;
  332.     while(l[0]) {
  333.         char *w = getword_conf(cmd->pool, &l);
  334.     if(!strcasecmp(w,"Indexes"))
  335.         d->opts |= OPT_INDEXES;
  336.     else if(!strcasecmp(w,"Includes"))
  337.         d->opts |= OPT_INCLUDES;
  338.     else if(!strcasecmp(w,"IncludesNOEXEC"))
  339.         d->opts |= (OPT_INCLUDES | OPT_INCNOEXEC);
  340.     else if(!strcasecmp(w,"FollowSymLinks"))
  341.         d->opts |= OPT_SYM_LINKS;
  342.     else if(!strcasecmp(w,"SymLinksIfOwnerMatch"))
  343.         d->opts |= OPT_SYM_OWNER;
  344.     else if(!strcasecmp(w,"execCGI"))
  345.         d->opts |= OPT_EXECCGI;
  346.     else if (!strcasecmp(w,"MultiViews"))
  347.         d->opts |= OPT_MULTI;
  348.     else if (!strcasecmp(w,"RunScripts")) /* AI backcompat. Yuck */
  349.         d->opts |= OPT_MULTI|OPT_EXECCGI;
  350.     else if(!strcasecmp(w,"None")) 
  351.         d->opts = OPT_NONE;
  352.     else if(!strcasecmp(w,"All")) 
  353.         d->opts = OPT_ALL;
  354.     else 
  355.         return pstrcat (cmd->pool, "Illegal option ", w, NULL);
  356.     }
  357.  
  358.     return NULL;
  359. }
  360.  
  361. char *require (cmd_parms *cmd, core_dir_config *c, char *arg)
  362. {
  363.     require_line *r;
  364.   
  365.     if (!c->requires)
  366.         c->requires = make_array (cmd->pool, 2, sizeof(require_line));
  367.     
  368.     r = (require_line *)push_array (c->requires);
  369.     r->requirement = pstrdup (cmd->pool, arg);
  370.     r->method_mask = cmd->limited;
  371.     return NULL;
  372. }
  373.  
  374. char *limit (cmd_parms *cmd, void *dummy, char *arg)
  375. {
  376.     char *limited_methods = getword(cmd->pool,&arg,'>');
  377.     int limited = 0;
  378.   
  379.     if (cmd->limited > 0) return "Can't nest <Limit> sections";
  380.     
  381.     while(limited_methods[0]) {
  382.         char *method = getword_conf (cmd->pool, &limited_methods);
  383.     if(!strcasecmp(method,"GET")) limited |= (1 << M_GET);
  384.     else if(!strcasecmp(method,"PUT")) limited |= (1 << M_PUT);
  385.     else if(!strcasecmp(method,"POST")) limited |= (1 << M_POST);
  386.     else if(!strcasecmp(method,"DELETE")) limited |= (1 << M_DELETE);
  387.     else return "unknown method in <Limit>";
  388.     }
  389.  
  390.     cmd->limited = limited;
  391.     return NULL;
  392. }
  393.  
  394. char *endlimit (cmd_parms *cmd, void *dummy, void *dummy2)
  395. {
  396.     if (cmd->limited == -1) return "</Limit> unexpected";
  397.     
  398.     cmd->limited = -1;
  399.     return NULL;
  400. }
  401.  
  402. static char *end_dir_magic = "</Directory> outside of any <Directory> section";
  403.  
  404. char *end_dirsection (cmd_parms *cmd, void *dummy) {
  405.     return end_dir_magic;
  406. }
  407.  
  408. char *dirsection (cmd_parms *cmd, void *dummy, char *arg)
  409. {
  410.     char *errmsg, *endp = strrchr (arg, '>');
  411.     int old_overrides = cmd->override;
  412.     char *old_path = cmd->path;
  413.     void *new_dir_conf = create_per_dir_config (cmd->pool);
  414.  
  415.     if (endp) *endp = '\0';
  416.  
  417.     if (cmd->path) return "<Directory> sections don't nest";
  418.     if (cmd->limited != -1) return "Can't have <Directory> within <Limit>";
  419.     
  420.     cmd->path = getword_conf (cmd->pool, &arg);
  421.     cmd->override = OR_ALL|ACCESS_CONF;
  422.  
  423.     errmsg = srm_command_loop (cmd, new_dir_conf);
  424.     add_per_dir_conf (cmd->server, new_dir_conf);
  425.     
  426.     cmd->path = old_path;
  427.     cmd->override = old_overrides;
  428.  
  429.     if (errmsg == end_dir_magic) return NULL;
  430.     return errmsg;
  431. }
  432.  
  433. /* httpd.conf commands... beginning with the <VirtualHost> business */
  434.  
  435. char *end_virthost_magic = "</Virtualhost> out of place";
  436.  
  437. char *end_virtualhost_section (cmd_parms *cmd, void *dummy) {
  438.     return end_virthost_magic;
  439. }
  440.  
  441. char *virtualhost_section (cmd_parms *cmd, void *dummy, char *arg)
  442. {
  443.     server_rec *main_server = cmd->server, *s;
  444.     char *errmsg, *endp = strrchr (arg, '>');
  445.     pool *p = cmd->pool, *ptemp = cmd->temp_pool;
  446.  
  447.     if (endp) *endp = '\0';
  448.     
  449.     if (is_virtual_server (main_server))
  450.     return "<VirtualHost> doesn't nest!";
  451.     
  452.     s = init_virtual_host (p, arg);
  453.     s->next = main_server->next;
  454.     main_server->next = s;
  455.     
  456.     cmd->server = s;
  457.     errmsg = srm_command_loop (cmd, s->lookup_defaults);
  458.     cmd->server = main_server;
  459.  
  460.     if (s->srm_confname)
  461.     process_resource_config (s, s->srm_confname, p, ptemp);
  462.  
  463.     if (s->access_confname)
  464.     process_resource_config (s, s->access_confname, p, ptemp);
  465.     
  466.     if (errmsg == end_virthost_magic) return NULL;
  467.     return errmsg;
  468. }
  469.  
  470. char *set_server_string_slot (cmd_parms *cmd, void *dummy, char *arg)
  471. {
  472.     /* This one's pretty generic... */
  473.   
  474.     int offset = (int)cmd->info;
  475.     char *struct_ptr = (char *)cmd->server;
  476.     
  477.     *(char **)(struct_ptr + offset) = pstrdup (cmd->pool, arg);
  478.     return NULL;
  479. }
  480.  
  481. char *server_type (cmd_parms *cmd, void *dummy, char *arg)
  482. {
  483.     if (!strcasecmp (arg, "inetd")) standalone = 0;
  484.     else if (!strcasecmp (arg, "standalone")) standalone = 1;
  485.     else return "ServerType must be either 'inetd' or 'standalone'";
  486.  
  487.     return NULL;
  488. }
  489.  
  490. char *server_port (cmd_parms *cmd, void *dummy, char *arg) {
  491.     cmd->server->port = atoi (arg);
  492.     return NULL;
  493. }
  494.  
  495. char *set_user (cmd_parms *cmd, void *dummy, char *arg) {
  496.     user_name = pstrdup (cmd->pool, arg);
  497.     user_id = uname2id (user_name);
  498.     return NULL;
  499. }
  500.  
  501. char *set_group (cmd_parms *cmd, void *dummy, char *arg) {
  502.     group_id = gname2id(arg);
  503.     return NULL;
  504. }
  505.  
  506. char *set_server_root (cmd_parms *cmd, void *dummy, char *arg) {
  507.     if (!is_directory (arg)) return "ServerRoot must be a valid directory";
  508.     strcpy (server_root, arg);
  509.     return NULL;
  510. }
  511.  
  512. char *set_timeout (cmd_parms *cmd, void *dummy, char *arg) {
  513.     cmd->server->timeout = atoi (arg);
  514.     return NULL;
  515. }
  516.  
  517. char *set_pidfile (cmd_parms *cmd, void *dummy, char *arg) {
  518.     pid_fname = pstrdup (cmd->pool, arg);
  519.     return NULL;
  520. }
  521.  
  522. char *set_idcheck (cmd_parms *cmd, void *dummy, int arg) {
  523.     cmd->server->do_rfc931 = arg;
  524.     return NULL;
  525. }
  526.  
  527. char *set_daemons_to_start (cmd_parms *cmd, void *dummy, char *arg) {
  528.     daemons_to_start = atoi (arg);
  529.     return NULL;
  530. }
  531.  
  532. char *set_min_free_servers (cmd_parms *cmd, void *dummy, char *arg) {
  533.     daemons_min_free = atoi (arg);
  534.     return NULL;
  535. }
  536.  
  537. char *set_max_free_servers (cmd_parms *cmd, void *dummy, char *arg) {
  538.     daemons_max_free = atoi (arg);
  539.     return NULL;
  540. }
  541.  
  542. char *set_server_limit (cmd_parms *cmd, void *dummy, char *arg) {
  543.     daemons_limit = atoi (arg);
  544.     return NULL;
  545. }
  546.  
  547. char *set_max_requests (cmd_parms *cmd, void *dummy, char *arg) {
  548.     max_requests_per_child = atoi (arg);
  549.     return NULL;
  550. }
  551.  
  552. char *set_bind_address (cmd_parms *cmd, void *dummy, char *arg) {
  553.     bind_address.s_addr = get_virthost_addr (arg, 1);
  554.     return NULL;
  555. }
  556.  
  557. /* Note --- change the mask below, and ErrorDocument will work from
  558.  * .htaccess files.  The question is, what AllowOverride should webmasters
  559.  * have to turn it off?
  560.  */
  561.  
  562. command_rec core_cmds[] = {
  563.  
  564. /* Old access config file commands */
  565.  
  566. { "<Directory", dirsection, NULL, RSRC_CONF, RAW_ARGS, NULL },
  567. { "</Directory>", end_dirsection, NULL, ACCESS_CONF, NO_ARGS, NULL },
  568. { "<Limit", limit, NULL, OR_ALL, RAW_ARGS, NULL },
  569. { "</Limit>", endlimit, NULL, OR_ALL, RAW_ARGS, NULL },
  570. { "AuthType", set_string_slot, (void*)XtOffsetOf(core_dir_config, auth_type),
  571.     OR_AUTHCFG, TAKE1, "an HTTP authorization type (e.g., \"Basic\")" },
  572. { "AuthName", set_string_slot, (void*)XtOffsetOf(core_dir_config, auth_name),
  573.     OR_AUTHCFG, RAW_ARGS, NULL },
  574. { "Require", require, NULL, OR_AUTHCFG, RAW_ARGS, NULL },
  575.     
  576. /* Old resource config file commands */
  577.   
  578. { "AccessFileName", set_access_name, NULL, RSRC_CONF, TAKE1, NULL },
  579. { "DocumentRoot", set_document_root, NULL, RSRC_CONF, TAKE1, NULL },
  580. { "ErrorDocument", set_error_document, NULL, RSRC_CONF, RAW_ARGS, NULL },
  581. { "AllowOverride", set_override, NULL, ACCESS_CONF, RAW_ARGS, NULL },
  582. { "Options", set_options, NULL, OR_OPTIONS, RAW_ARGS, NULL },
  583. { "DefaultType", set_string_slot,
  584.     (void*)XtOffsetOf (core_dir_config, default_type),
  585.     OR_FILEINFO, TAKE1, "the default MIME type for untypable files" },
  586.  
  587. /* Old server config file commands */
  588.  
  589. { "ServerType", server_type, NULL, RSRC_CONF, TAKE1,"'inetd' or 'standalone'"},
  590. { "Port", server_port, NULL, RSRC_CONF, TAKE1, "a TCP port number"},
  591. { "User", set_user, NULL, RSRC_CONF, TAKE1, "a username"},
  592. { "Group", set_group, NULL, RSRC_CONF, TAKE1, "a group name"},
  593. { "ServerAdmin", set_server_string_slot,
  594.   (void *)XtOffsetOf (server_rec, server_admin), RSRC_CONF, TAKE1,
  595.   "The email address of the server administrator" },
  596. { "ServerName", set_server_string_slot,
  597.   (void *)XtOffsetOf (server_rec, server_hostname), RSRC_CONF, TAKE1,
  598.   "The hostname of the server" },
  599. { "ServerRoot", set_server_root, NULL, RSRC_CONF, TAKE1, "a directory"},
  600. { "ErrorLog", set_server_string_slot,
  601.   (void *)XtOffsetOf (server_rec, error_fname), RSRC_CONF, TAKE1,
  602.   "the filename of the error log" },
  603. { "PidFile", set_pidfile, NULL, RSRC_CONF, TAKE1,
  604.     "a file for logging the server process ID"},
  605. { "AccessConfig", set_server_string_slot,
  606.   (void *)XtOffsetOf (server_rec, access_confname), RSRC_CONF, TAKE1,
  607.   "the filename of the access config file" },
  608. { "ResourceConfig", set_server_string_slot,
  609.   (void *)XtOffsetOf (server_rec, srm_confname), RSRC_CONF, TAKE1,
  610.   "the filename of the resource config file" },
  611. { "Timeout", set_timeout, NULL, RSRC_CONF, TAKE1, "timeout duration (sec)"},
  612. { "IdentityCheck", set_idcheck, NULL, RSRC_CONF, FLAG, NULL },
  613. { "CacheNegotiatedDocs", },
  614. { "StartServers", set_daemons_to_start, NULL, RSRC_CONF, TAKE1, NULL },
  615. { "MinSpareServers", set_min_free_servers, NULL, RSRC_CONF, TAKE1, NULL },
  616. { "MaxSpareServers", set_max_free_servers, NULL, RSRC_CONF, TAKE1, NULL },
  617. { "MaxServers", set_max_free_servers, NULL, RSRC_CONF, TAKE1, NULL },
  618. { "ServersSafetyLimit", set_server_limit, NULL, RSRC_CONF, TAKE1, NULL },
  619. { "MaxClients", set_server_limit, NULL, RSRC_CONF, TAKE1, NULL },
  620. { "MaxRequestsPerChild", set_max_requests, NULL, RSRC_CONF, TAKE1, NULL },
  621. { "BindAddress", set_bind_address, NULL, RSRC_CONF, TAKE1,
  622.   "'*', a numeric IP address, or the name of a host with a unique IP address"},
  623. { "<VirtualHost", virtualhost_section, NULL, RSRC_CONF, RAW_ARGS, NULL },
  624. { "</VirtualHost>", end_virtualhost_section, NULL, RSRC_CONF, NO_ARGS, NULL },
  625. { NULL },
  626. };
  627.  
  628. /*****************************************************************
  629.  *
  630.  * Core handlers for various phases of server operation...
  631.  */
  632.  
  633. int core_translate (request_rec *r)
  634. {
  635.     void *sconf = r->server->module_config;
  636.     core_server_config *conf = get_module_config (sconf, &core_module);
  637.   
  638.     if (r->uri[0] != '/') return BAD_REQUEST;
  639.     
  640.     r->filename = pstrcat (r->pool, conf->document_root, r->uri, NULL);
  641.     return OK;
  642. }
  643.  
  644. int do_nothing (request_rec *r) { return OK; }
  645.  
  646. /*
  647.  * Default handler for MIME types without other handlers.  Only GET
  648.  * at this point... anyone who wants to write a generic handler for
  649.  * PUT or POST is free to do so, but it seems unwise to provide any
  650.  * defaults yet...
  651.  */
  652.  
  653. int default_handler (request_rec *r)
  654. {
  655.     int errstatus;
  656.     FILE *f;
  657.     
  658.     if (r->method_number != M_GET) return DECLINED;
  659.     if (r->finfo.st_mode == 0 || (r->path_info && *r->path_info)) {
  660.     log_reason("File does not exist", r->filename, r);
  661.     return NOT_FOUND;
  662.     }
  663.     
  664.     if ((errstatus = set_content_length (r, r->finfo.st_size))
  665.     || (errstatus = set_last_modified (r, r->finfo.st_mtime)))
  666.         return errstatus;
  667.     
  668.     f = fopen (r->filename, "r");
  669.  
  670.     if (f == NULL) {
  671.         log_reason("file permissions deny server access", r->filename, r);
  672.         return FORBIDDEN;
  673.     }
  674.       
  675.     soft_timeout ("send", r);
  676.     
  677.     send_http_header (r);
  678.     if (!r->header_only) send_fd (f, r);
  679.     fclose (f);
  680.     return OK;
  681. }
  682.  
  683. handler_rec core_handlers[] = {
  684. { "*/*", default_handler },
  685. { NULL }
  686. };
  687.  
  688. module core_module = {
  689.    STANDARD_MODULE_STUFF,
  690.    NULL,            /* initializer */
  691.    create_core_dir_config,    /* create per-directory config structure */
  692.    merge_core_dir_configs,    /* merge per-directory config structures */
  693.    create_core_server_config,    /* create per-server config structure */
  694.    merge_core_server_configs,    /* merge per-server config structures */
  695.    core_cmds,            /* command table */
  696.    core_handlers,        /* handlers */
  697.    core_translate,        /* translate_handler */
  698.    NULL,            /* check_user_id */
  699.    NULL,            /* check auth */
  700.    do_nothing,            /* check access */
  701.    do_nothing,            /* type_checker */
  702.    NULL,            /* pre-run fixups */
  703.    NULL                /* logger */
  704. };
  705.